home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / djgpp / src / binutils.252 / gas / config / tc-sh.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-09-13  |  27.6 KB  |  1,354 lines
  1. /* tc-sh.c -- Assemble code for the Hitachi Super-H
  2.  
  3.    Copyright (C) 1993 Free Software Foundation.
  4.  
  5.    This file is part of GAS, the GNU Assembler.
  6.  
  7.    GAS is free software; you can redistribute it and/or modify
  8.    it under the terms of the GNU General Public License as published by
  9.    the Free Software Foundation; either version 2, or (at your option)
  10.    any later version.
  11.  
  12.    GAS is distributed in the hope that it will be useful,
  13.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.    GNU General Public License for more details.
  16.  
  17.    You should have received a copy of the GNU General Public License
  18.    along with GAS; see the file COPYING.  If not, write to
  19.    the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20.  
  21. /*
  22.    Written By Steve Chamberlain
  23.    sac@cygnus.com
  24.  */
  25.  
  26. #include <stdio.h>
  27. #include "as.h"
  28. #include "bfd.h"
  29. #include "subsegs.h"
  30. #define DEFINE_TABLE
  31. #include "../opcodes/sh-opc.h"
  32. #include <ctype.h>
  33.  
  34. const char comment_chars[] = "!";
  35. const char line_separator_chars[] = ";";
  36. const char line_comment_chars[] = "!#";
  37.  
  38. /* This table describes all the machine specific pseudo-ops the assembler
  39.    has to support.  The fields are:
  40.    pseudo-op name without dot
  41.    function to call to execute this pseudo-op
  42.    Integer arg to pass to the function
  43.  */
  44.  
  45. void cons ();
  46. void s_align_bytes ();
  47.  
  48. const pseudo_typeS md_pseudo_table[] =
  49. {
  50.   {"int", cons, 4},
  51.   {"word", cons, 2},
  52.   {"form", listing_psize, 0},
  53.   {"heading", listing_title, 0},
  54.   {"import", s_ignore, 0},
  55.   {"page", listing_eject, 0},
  56.   {"program", s_ignore, 0},
  57.   {0, 0, 0}
  58. };
  59.  
  60. /*int md_reloc_size; */
  61.  
  62. static int relax;        /* set if -relax seen */
  63.  
  64. const char EXP_CHARS[] = "eE";
  65.  
  66. /* Chars that mean this number is a floating point constant */
  67. /* As in 0f12.456 */
  68. /* or    0d1.2345e12 */
  69. const char FLT_CHARS[] = "rRsSfFdDxXpP";
  70.  
  71. #define C(a,b) ENCODE_RELAX(a,b)
  72.  
  73. #define JREG 14            /* Register used as a temp when relaxing */
  74. #define ENCODE_RELAX(what,length) (((what) << 4) + (length))
  75. #define GET_WHAT(x) ((x>>4))
  76.  
  77. /* These are the two types of relaxable instrction */
  78. #define COND_JUMP 1
  79. #define UNCOND_JUMP  2
  80.  
  81. #define UNDEF_DISP 0
  82. #define COND8  1
  83. #define COND12 2
  84. #define COND32 3
  85. #define UNCOND12 1
  86. #define UNCOND32 2
  87. #define UNDEF_WORD_DISP 4
  88. #define END 5
  89.  
  90. #define UNCOND12 1
  91. #define UNCOND32 2
  92.  
  93. #define COND8_F 254
  94. #define COND8_M -256
  95. #define COND8_LENGTH 2
  96. #define COND12_F (4094 - 4)    /* -4 since there are two extra */
  97. /* instructions needed */
  98. #define COND12_M -4096
  99. #define COND12_LENGTH 6
  100. #define COND32_F (1<<30)
  101. #define COND32_M -(1<<30)
  102. #define COND32_LENGTH 14
  103.  
  104. #define COND8_RANGE(x) ((x) > COND8_M && (x) < COND8_F)
  105. #define COND12_RANGE(x) ((x) > COND12_M && (x) < COND12_F)
  106.  
  107. #define UNCOND12_F 4094
  108. #define UNCOND12_M -4096
  109. #define UNCOND12_LENGTH 2
  110.  
  111. #define UNCOND32_F (1<<30)
  112. #define UNCOND32_M -(1<<30)
  113. #define UNCOND32_LENGTH 14
  114.  
  115.  
  116. const relax_typeS md_relax_table[C (END, 0)];
  117.  
  118. static struct hash_control *opcode_hash_control;    /* Opcode mnemonics */
  119.  
  120. /*
  121.    This function is called once, at assembler startup time.  This should
  122.    set up all the tables, etc that the MD part of the assembler needs
  123.  */
  124.  
  125. void
  126. md_begin ()
  127. {
  128.   sh_opcode_info *opcode;
  129.   char *prev_name = "";
  130.  
  131.   opcode_hash_control = hash_new ();
  132.  
  133.   /* Insert unique names into hash table */
  134.   for (opcode = sh_table; opcode->name; opcode++)
  135.     {
  136.       if (strcmp (prev_name, opcode->name))
  137.     {
  138.       prev_name = opcode->name;
  139.       hash_insert (opcode_hash_control, opcode->name, (char *) opcode);
  140.     }
  141.       else
  142.     {
  143.       /* Make all the opcodes with the same name point to the same
  144.          string */
  145.       opcode->name = prev_name;
  146.     }
  147.     }
  148.  
  149.   /* Initialize the relax table */
  150.   md_relax_table[C (COND_JUMP, COND8)].rlx_forward = COND8_F;
  151.   md_relax_table[C (COND_JUMP, COND8)].rlx_backward = COND8_M;
  152.   md_relax_table[C (COND_JUMP, COND8)].rlx_length = COND8_LENGTH;
  153.   md_relax_table[C (COND_JUMP, COND8)].rlx_more = C (COND_JUMP, COND12);
  154.  
  155.   md_relax_table[C (COND_JUMP, COND12)].rlx_forward = COND12_F;
  156.   md_relax_table[C (COND_JUMP, COND12)].rlx_backward = COND12_M;
  157.   md_relax_table[C (COND_JUMP, COND12)].rlx_length = COND12_LENGTH;
  158.   md_relax_table[C (COND_JUMP, COND12)].rlx_more = C (COND_JUMP, COND32);
  159.  
  160.   md_relax_table[C (COND_JUMP, COND32)].rlx_forward = COND32_F;
  161.   md_relax_table[C (COND_JUMP, COND32)].rlx_backward = COND32_M;
  162.   md_relax_table[C (COND_JUMP, COND32)].rlx_length = COND32_LENGTH;
  163.   md_relax_table[C (COND_JUMP, COND32)].rlx_more = 0;
  164.  
  165.  
  166.   md_relax_table[C (UNCOND_JUMP, UNCOND12)].rlx_forward = UNCOND12_F;
  167.   md_relax_table[C (UNCOND_JUMP, UNCOND12)].rlx_backward = UNCOND12_M;
  168.   md_relax_table[C (UNCOND_JUMP, UNCOND12)].rlx_length = UNCOND12_LENGTH;
  169.   md_relax_table[C (UNCOND_JUMP, UNCOND12)].rlx_more = C (UNCOND_JUMP, UNCOND32);
  170.  
  171.   md_relax_table[C (UNCOND_JUMP, UNCOND32)].rlx_forward = UNCOND32_F;
  172.   md_relax_table[C (UNCOND_JUMP, UNCOND32)].rlx_backward = UNCOND32_M;
  173.   md_relax_table[C (UNCOND_JUMP, UNCOND32)].rlx_length = UNCOND32_LENGTH;
  174.   md_relax_table[C (UNCOND_JUMP, UNCOND32)].rlx_more = 0;
  175.  
  176.  
  177. }
  178.  
  179. static int reg_m;
  180. static int reg_n;
  181. static expressionS immediate;    /* absolute expression */
  182.  
  183. typedef struct
  184.   {
  185.     sh_arg_type type;
  186.     int reg;
  187.   }
  188.  
  189. sh_operand_info;
  190.  
  191. /* try and parse a reg name, returns number of chars consumed */
  192. static int
  193. parse_reg (src, mode, reg)
  194.      char *src;
  195.      int *mode;
  196.      int *reg;
  197. {
  198.   if (src[0] == 'r')
  199.     {
  200.       if (src[1] == '1')
  201.     {
  202.       if (src[2] >= '0' && src[2] <= '5')
  203.         {
  204.           *mode = A_REG_N;
  205.           *reg = 10 + src[2] - '0';
  206.           return 3;
  207.         }
  208.     }
  209.       if (src[1] >= '0' && src[1] <= '9')
  210.     {
  211.       *mode = A_REG_N;
  212.       *reg = (src[1] - '0');
  213.       return 2;
  214.     }
  215.     }
  216.  
  217.   if (src[0] == 's' && src[1] == 'r')
  218.     {
  219.       *mode = A_SR;
  220.       return 2;
  221.     }
  222.  
  223.   if (src[0] == 's' && src[1] == 'p')
  224.     {
  225.       *mode = A_REG_N;
  226.       *reg = 15;
  227.       return 2;
  228.     }
  229.  
  230.   if (src[0] == 'p' && src[1] == 'r')
  231.     {
  232.       *mode = A_PR;
  233.       return 2;
  234.     }
  235.   if (src[0] == 'p' && src[1] == 'c')
  236.     {
  237.       *mode = A_DISP_PC;
  238.       return 2;
  239.     }
  240.   if (src[0] == 'g' && src[1] == 'b' && src[2] == 'r')
  241.     {
  242.       *mode = A_GBR;
  243.       return 3;
  244.     }
  245.   if (src[0] == 'v' && src[1] == 'b' && src[2] == 'r')
  246.     {
  247.       *mode = A_VBR;
  248.       return 3;
  249.     }
  250.  
  251.   if (src[0] == 'm' && src[1] == 'a' && src[2] == 'c')
  252.     {
  253.       if (src[3] == 'l')
  254.     {
  255.       *mode = A_MACL;
  256.       return 4;
  257.     }
  258.       if (src[3] == 'h')
  259.     {
  260.       *mode = A_MACH;
  261.       return 4;
  262.     }
  263.     }
  264.  
  265.   return 0;
  266. }
  267.  
  268. static symbolS *dot()
  269. {
  270.   const char *fake;
  271.  
  272.   /* JF: '.' is pseudo symbol with value of current location
  273.      in current segment.  */
  274.   fake = FAKE_LABEL_NAME;
  275.   return  symbol_new (fake,
  276.               now_seg,
  277.               (valueT) frag_now_fix (),
  278.               frag_now);
  279.  
  280. }
  281.  
  282.  
  283. static
  284. char *
  285. parse_exp (s)
  286.      char *s;
  287. {
  288.   char *save;
  289.   char *new;
  290.  
  291.   save = input_line_pointer;
  292.   input_line_pointer = s;
  293.   expression (&immediate);
  294.   if (immediate.X_op == O_absent)
  295.     as_bad ("missing operand");
  296.   new = input_line_pointer;
  297.   input_line_pointer = save;
  298.   return new;
  299. }
  300.  
  301.  
  302. /* The many forms of operand:
  303.  
  304.    Rn                   Register direct
  305.    @Rn                  Register indirect
  306.    @Rn+                 Autoincrement
  307.    @-Rn                 Autodecrement
  308.    @(disp:4,Rn)
  309.    @(disp:8,GBR)
  310.    @(disp:8,PC)
  311.  
  312.    @(R0,Rn)
  313.    @(R0,GBR)
  314.  
  315.    disp:8
  316.    disp:12
  317.    #imm8
  318.    pr, gbr, vbr, macl, mach
  319.  
  320.  */
  321.  
  322. static
  323. char *
  324. parse_at (src, op)
  325.      char *src;
  326.      sh_operand_info *op;
  327. {
  328.   int len;
  329.   int mode;
  330.   src++;
  331.   if (src[0] == '-')
  332.     {
  333.       /* Must be predecrement */
  334.       src++;
  335.  
  336.       len = parse_reg (src, &mode, &(op->reg));
  337.       if (mode != A_REG_N)
  338.     as_bad ("illegal register after @-");
  339.  
  340.       op->type = A_DEC_N;
  341.       src += len;
  342.     }
  343.   else if (src[0] == '(')
  344.     {
  345.       /* Could be @(disp, rn), @(disp, gbr), @(disp, pc),  @(r0, gbr) or
  346.          @(r0, rn) */
  347.       src++;
  348.       len = parse_reg (src, &mode, &(op->reg));
  349.       if (len && mode == A_REG_N)
  350.     {
  351.       src += len;
  352.       if (op->reg != 0)
  353.         {
  354.           as_bad ("must be @(r0,...)");
  355.         }
  356.       if (src[0] == ',')
  357.         src++;
  358.       /* Now can be rn or gbr */
  359.       len = parse_reg (src, &mode, &(op->reg));
  360.       if (mode == A_GBR)
  361.         {
  362.           op->type = A_R0_GBR;
  363.         }
  364.       else if (mode == A_REG_N)
  365.         {
  366.           op->type = A_IND_R0_REG_N;
  367.         }
  368.       else
  369.         {
  370.           as_bad ("syntax error in @(r0,...)");
  371.         }
  372.     }
  373.       else
  374.     {
  375.       /* Must be an @(disp,.. thing) */
  376.       src = parse_exp (src);
  377.       if (src[0] == ',')
  378.         src++;
  379.       /* Now can be rn, gbr or pc */
  380.       len = parse_reg (src, &mode, &op->reg);
  381.       if (len)
  382.         {
  383.           if (mode == A_REG_N)
  384.         {
  385.           op->type = A_DISP_REG_N;
  386.         }
  387.           else if (mode == A_GBR)
  388.         {
  389.           op->type = A_DISP_GBR;
  390.         }
  391.           else if (mode == A_DISP_PC)
  392.         {
  393.           /* Turn a plain @(4,pc) into @(.+4,pc) */
  394.           if (immediate.X_op == O_constant) { 
  395.             immediate.X_add_symbol = dot();
  396.             immediate.X_op = O_symbol;
  397.           }
  398.           op->type = A_DISP_PC;
  399.         }
  400.           else
  401.         {
  402.           as_bad ("syntax error in @(disp,[Rn, gbr, pc])");
  403.         }
  404.         }
  405.       else
  406.         {
  407.           as_bad ("syntax error in @(disp,[Rn, gbr, pc])");
  408.         }
  409.     }
  410.       src += len;
  411.       if (src[0] != ')')
  412.     as_bad ("expecting )");
  413.       else
  414.     src++;
  415.     }
  416.   else
  417.     {
  418.       src += parse_reg (src, &mode, &(op->reg));
  419.       if (mode != A_REG_N)
  420.     {
  421.       as_bad ("illegal register after @");
  422.     }
  423.       if (src[0] == '+')
  424.     {
  425.       op->type = A_INC_N;
  426.       src++;
  427.     }
  428.       else
  429.     {
  430.       op->type = A_IND_N;
  431.     }
  432.     }
  433.   return src;
  434. }
  435.  
  436. static void
  437. get_operand (ptr, op)
  438.      char **ptr;
  439.      sh_operand_info *op;
  440. {
  441.   char *src = *ptr;
  442.   int mode = -1;
  443.   unsigned int len;
  444.  
  445.   if (src[0] == '#')
  446.     {
  447.       src++;
  448.       *ptr = parse_exp (src);
  449.       op->type = A_IMM;
  450.       return;
  451.     }
  452.  
  453.   else if (src[0] == '@')
  454.     {
  455.       *ptr = parse_at (src, op);
  456.       return;
  457.     }
  458.   len = parse_reg (src, &mode, &(op->reg));
  459.   if (len)
  460.     {
  461.       *ptr = src + len;
  462.       op->type = mode;
  463.       return;
  464.     }
  465.   else
  466.     {
  467.       /* Not a reg, the only thing left is a displacement */
  468.       *ptr = parse_exp (src);
  469.       op->type = A_DISP_PC;
  470.       return;
  471.     }
  472. }
  473.  
  474. static
  475. char *
  476. get_operands (info, args, operand)
  477.      sh_opcode_info *info;
  478.      char *args;
  479.      sh_operand_info *operand;
  480.  
  481. {
  482.   char *ptr = args;
  483.   if (info->arg[0])
  484.     {
  485.       ptr++;
  486.  
  487.       get_operand (&ptr, operand + 0);
  488.       if (info->arg[1])
  489.     {
  490.       if (*ptr == ',')
  491.         {
  492.           ptr++;
  493.         }
  494.       get_operand (&ptr, operand + 1);
  495.     }
  496.       else
  497.     {
  498.       operand[1].type = 0;
  499.     }
  500.     }
  501.   else
  502.     {
  503.       operand[0].type = 0;
  504.       operand[1].type = 0;
  505.     }
  506.   return ptr;
  507. }
  508.  
  509. /* Passed a pointer to a list of opcodes which use different
  510.    addressing modes, return the opcode which matches the opcodes
  511.    provided
  512.  */
  513.  
  514. static
  515. sh_opcode_info *
  516. get_specific (opcode, operands)
  517.      sh_opcode_info *opcode;
  518.      sh_operand_info *operands;
  519. {
  520.   sh_opcode_info *this_try = opcode;
  521.   char *name = opcode->name;
  522.   int arg_to_test = 0;
  523.   int n = 0;
  524.   while (opcode->name)
  525.     {
  526.       this_try = opcode++;
  527.       if (this_try->name != name)
  528.     {
  529.       /* We've looked so far down the table that we've run out of
  530.          opcodes with the same name */
  531.       return 0;
  532.     }
  533.       /* look at both operands needed by the opcodes and provided by
  534.          the user - since an arg test will often fail on the same arg
  535.          again and again, we'll try and test the last failing arg the
  536.          first on each opcode try */
  537.  
  538.       for (n = 0; this_try->arg[n]; n++)
  539.     {
  540.       sh_operand_info *user = operands + arg_to_test;
  541.       sh_arg_type arg = this_try->arg[arg_to_test];
  542.       switch (arg)
  543.         {
  544.         case A_IMM:
  545.         case A_BDISP12:
  546.         case A_BDISP8:
  547.         case A_DISP_GBR:
  548.         case A_DISP_PC:
  549.         case A_MACH:
  550.         case A_PR:
  551.         case A_MACL:
  552.           if (user->type != arg)
  553.         goto fail;
  554.           break;
  555.         case A_R0:
  556.           /* opcode needs r0 */
  557.           if (user->type != A_REG_N || user->reg != 0)
  558.         goto fail;
  559.           break;
  560.         case A_R0_GBR:
  561.           if (user->type != A_R0_GBR || user->reg != 0)
  562.         goto fail;
  563.           break;
  564.  
  565.         case A_REG_N:
  566.         case A_INC_N:
  567.         case A_DEC_N:
  568.         case A_IND_N:
  569.         case A_IND_R0_REG_N:
  570.         case A_DISP_REG_N:
  571.           /* Opcode needs rn */
  572.           if (user->type != arg)
  573.         goto fail;
  574.           reg_n = user->reg;
  575.           break;
  576.         case A_GBR:
  577.         case A_SR:
  578.         case A_VBR:
  579.           if (user->type != arg)
  580.         goto fail;
  581.           break;
  582.  
  583.         case A_REG_M:
  584.         case A_INC_M:
  585.         case A_DEC_M:
  586.         case A_IND_M:
  587.         case A_IND_R0_REG_M:
  588.         case A_DISP_REG_M:
  589.           /* Opcode needs rn */
  590.           if (user->type != arg - A_REG_M + A_REG_N)
  591.         goto fail;
  592.           reg_m = user->reg;
  593.           break;
  594.         default:
  595.           printf ("unhandled %d\n", arg);
  596.           goto fail;
  597.         }
  598.       /* If we did 0, test 1 next, else 0 */
  599.       arg_to_test = 1 - arg_to_test;
  600.     }
  601.       return this_try;
  602.     fail:;
  603.     }
  604.  
  605.   return 0;
  606. }
  607.  
  608. int
  609. check (operand, low, high)
  610.      expressionS *operand;
  611.      int low;
  612.      int high;
  613. {
  614.   if (operand->X_op != O_constant
  615.       || operand->X_add_number < low
  616.       || operand->X_add_number > high)
  617.     {
  618.       as_bad ("operand must be absolute in range %d..%d", low, high);
  619.     }
  620.   return operand->X_add_number;
  621. }
  622.  
  623.  
  624. static void
  625. insert (where, how, pcrel)
  626.      char *where;
  627.      int how;
  628.      int pcrel;
  629. {
  630.   fix_new_exp (frag_now,
  631.            where - frag_now->fr_literal,
  632.            4,
  633.            &immediate,
  634.            pcrel,
  635.            how);
  636.  
  637. }
  638.  
  639. static void
  640. build_relax (opcode)
  641.      sh_opcode_info *opcode;
  642. {
  643.   int len;
  644.   char *p;
  645.   if (opcode->arg[0] == A_BDISP8)
  646.     {
  647.       p = frag_var (rs_machine_dependent,
  648.             md_relax_table[C (COND_JUMP, COND32)].rlx_length,
  649.             len = md_relax_table[C (COND_JUMP, COND8)].rlx_length,
  650.             C (COND_JUMP, 0),
  651.             immediate.X_add_symbol,
  652.             immediate.X_add_number,
  653.             0);
  654.       p[0] = (opcode->nibbles[0] << 4) | (opcode->nibbles[1]);
  655.     }
  656.   else if (opcode->arg[0] == A_BDISP12)
  657.     {
  658.       p = frag_var (rs_machine_dependent,
  659.             md_relax_table[C (UNCOND_JUMP, UNCOND32)].rlx_length,
  660.          len = md_relax_table[C (UNCOND_JUMP, UNCOND12)].rlx_length,
  661.             C (UNCOND_JUMP, 0),
  662.             immediate.X_add_symbol,
  663.             immediate.X_add_number,
  664.             0);
  665.       p[0] = (opcode->nibbles[0] << 4);
  666.     }
  667.  
  668. }
  669.  
  670. /* Now we know what sort of opcodes it is, lets build the bytes -
  671.  */
  672. static void
  673. build_Mytes (opcode, operand)
  674.      sh_opcode_info *opcode;
  675.      sh_operand_info *operand;
  676.  
  677. {
  678.   int index;
  679.   char nbuf[4];
  680.   char *output = frag_more (2);
  681.  
  682.   nbuf[0] = 0;
  683.   nbuf[1] = 0;
  684.   nbuf[2] = 0;
  685.   nbuf[3] = 0;
  686.  
  687.   for (index = 0; index < 4; index++)
  688.     {
  689.       sh_nibble_type i = opcode->nibbles[index];
  690.       if (i < 16)
  691.     {
  692.       nbuf[index] = i;
  693.     }
  694.       else
  695.     {
  696.       switch (i)
  697.         {
  698.         case REG_N:
  699.           nbuf[index] = reg_n;
  700.           break;
  701.         case REG_M:
  702.           nbuf[index] = reg_m;
  703.           break;
  704.         case DISP_4:
  705.           insert (output + 1, R_SH_IMM4, 0);
  706.           break;
  707.         case IMM_4BY4:
  708.           insert (output + 1, R_SH_IMM4BY4, 0);
  709.           break;
  710.         case IMM_4BY2:
  711.           insert (output + 1, R_SH_IMM4BY2, 0);
  712.           break;
  713.         case IMM_4:
  714.           insert (output + 1, R_SH_IMM4, 0);
  715.           break;
  716.         case IMM_8BY4:
  717.           insert (output + 1, R_SH_IMM8BY4, 0);
  718.           break;
  719.         case IMM_8BY2:
  720.           insert (output + 1, R_SH_IMM8BY2, 0);
  721.           break;
  722.         case IMM_8:
  723.           insert (output + 1, R_SH_IMM8, 0);
  724.           break;
  725.         case PCRELIMM_8BY4:
  726.           insert (output + 1, R_SH_PCRELIMM8BY4, 1);
  727.           break;
  728.         case PCRELIMM_8BY2:
  729.           insert (output + 1, R_SH_PCRELIMM8BY2, 1);
  730.           break;
  731.         default:
  732.           printf ("failed for %d\n", i);
  733.         }
  734.     }
  735.     }
  736.   output[0] = (nbuf[0] << 4) | (nbuf[1]);
  737.   output[1] = (nbuf[2] << 4) | (nbuf[3]);
  738. }
  739.  
  740. /* This is the guts of the machine-dependent assembler.  STR points to a
  741.    machine dependent instruction.  This function is supposed to emit
  742.    the frags/bytes it assembles to.
  743.  */
  744.  
  745. void
  746. md_assemble (str)
  747.      char *str;
  748. {
  749.   unsigned char *op_start;
  750.   unsigned char *op_end;
  751.   sh_operand_info operand[2];
  752.   sh_opcode_info *opcode;
  753.   char name[20];
  754.   int nlen = 0;
  755.   char *p;
  756.   /* Drop leading whitespace */
  757.   while (*str == ' ')
  758.     str++;
  759.  
  760.   /* find the op code end */
  761.   for (op_start = op_end = (unsigned char *) (str);
  762.        *op_end
  763.        && nlen < 20
  764.        && !is_end_of_line[*op_end] && *op_end != ' ';
  765.        op_end++)
  766.     {
  767.       name[nlen] = op_start[nlen];
  768.       nlen++;
  769.     }
  770.   name[nlen] = 0;
  771.  
  772.   if (nlen == 0)
  773.     {
  774.       as_bad ("can't find opcode ");
  775.     }
  776.  
  777.   opcode = (sh_opcode_info *) hash_find (opcode_hash_control, name);
  778.  
  779.   if (opcode == NULL)
  780.     {
  781.       as_bad ("unknown opcode");
  782.       return;
  783.     }
  784.  
  785.   if (opcode->arg[0] == A_BDISP12
  786.       || opcode->arg[0] == A_BDISP8)
  787.     {
  788.       parse_exp (op_end + 1);
  789.       build_relax (opcode);
  790.     }
  791.   else
  792.     {
  793.       if (opcode->arg[0] != A_END)
  794.     {
  795.       get_operands (opcode, op_end, operand);
  796.     }
  797.       opcode = get_specific (opcode, operand);
  798.  
  799.       if (opcode == 0)
  800.     {
  801.       /* Couldn't find an opcode which matched the operands */
  802.       char *where = frag_more (2);
  803.  
  804.       where[0] = 0x0;
  805.       where[1] = 0x0;
  806.       as_bad ("invalid operands for opcode");
  807.       return;
  808.     }
  809.  
  810.       build_Mytes (opcode, operand);
  811.     }
  812.  
  813. }
  814.  
  815. void
  816. DEFUN (tc_crawl_symbol_chain, (headers),
  817.        object_headers * headers)
  818. {
  819.   printf ("call to tc_crawl_symbol_chain \n");
  820. }
  821.  
  822. symbolS *
  823. DEFUN (md_undefined_symbol, (name),
  824.        char *name)
  825. {
  826.   return 0;
  827. }
  828.  
  829. void
  830. DEFUN (tc_headers_hook, (headers),
  831.        object_headers * headers)
  832. {
  833.   printf ("call to tc_headers_hook \n");
  834. }
  835.  
  836. /* Various routines to kill one day */
  837. /* Equal to MAX_PRECISION in atof-ieee.c */
  838. #define MAX_LITTLENUMS 6
  839.  
  840. /* Turn a string in input_line_pointer into a floating point constant of type
  841.    type, and store the appropriate bytes in *litP.  The number of LITTLENUMS
  842.    emitted is stored in *sizeP .  An error message is returned, or NULL on OK.
  843.  */
  844. char *
  845. md_atof (type, litP, sizeP)
  846.      char type;
  847.      char *litP;
  848.      int *sizeP;
  849. {
  850.   int prec;
  851.   LITTLENUM_TYPE words[MAX_LITTLENUMS];
  852.   LITTLENUM_TYPE *wordP;
  853.   char *t;
  854.   char *atof_ieee ();
  855.  
  856.   switch (type)
  857.     {
  858.     case 'f':
  859.     case 'F':
  860.     case 's':
  861.     case 'S':
  862.       prec = 2;
  863.       break;
  864.  
  865.     case 'd':
  866.     case 'D':
  867.     case 'r':
  868.     case 'R':
  869.       prec = 4;
  870.       break;
  871.  
  872.     case 'x':
  873.     case 'X':
  874.       prec = 6;
  875.       break;
  876.  
  877.     case 'p':
  878.     case 'P':
  879.       prec = 6;
  880.       break;
  881.  
  882.     default:
  883.       *sizeP = 0;
  884.       return "Bad call to MD_NTOF()";
  885.     }
  886.   t = atof_ieee (input_line_pointer, type, words);
  887.   if (t)
  888.     input_line_pointer = t;
  889.  
  890.   *sizeP = prec * sizeof (LITTLENUM_TYPE);
  891.   for (wordP = words; prec--;)
  892.     {
  893.       md_number_to_chars (litP, (long) (*wordP++), sizeof (LITTLENUM_TYPE));
  894.       litP += sizeof (LITTLENUM_TYPE);
  895.     }
  896.   return 0;
  897. }
  898.  
  899. CONST char *md_shortopts = "";
  900. struct option md_longopts[] = {
  901. #define OPTION_RELAX (OPTION_MD_BASE)
  902.   {"relax", no_argument, NULL, OPTION_RELAX},
  903.   {NULL, no_argument, NULL, 0}
  904. };
  905. size_t md_longopts_size = sizeof(md_longopts);
  906.  
  907. int
  908. md_parse_option (c, arg)
  909.      int c;
  910.      char *arg;
  911. {
  912.   switch (c)
  913.     {
  914.     case OPTION_RELAX:
  915.       relax = 1;
  916.       break;
  917.  
  918.     default:
  919.       return 0;
  920.     }
  921.  
  922.   return 1;
  923. }
  924.  
  925. void
  926. md_show_usage (stream)
  927.      FILE *stream;
  928. {
  929.   fprintf(stream, "\
  930. SH options:\n\
  931. -relax            alter jump instructions for long displacements\n");
  932. }
  933.  
  934. int md_short_jump_size;
  935.  
  936. void
  937. tc_Nout_fix_to_chars ()
  938. {
  939.   printf ("call to tc_Nout_fix_to_chars \n");
  940.   abort ();
  941. }
  942.  
  943. void
  944. md_create_short_jump (ptr, from_Nddr, to_Nddr, frag, to_symbol)
  945.      char *ptr;
  946.      addressT from_Nddr;
  947.      addressT to_Nddr;
  948.      fragS *frag;
  949.      symbolS *to_symbol;
  950. {
  951.   as_fatal ("failed sanity check.");
  952. }
  953.  
  954. void
  955. md_create_long_jump (ptr, from_Nddr, to_Nddr, frag, to_symbol)
  956.      char *ptr;
  957.      addressT from_Nddr, to_Nddr;
  958.      fragS *frag;
  959.      symbolS *to_symbol;
  960. {
  961.   as_fatal ("failed sanity check.");
  962. }
  963.  
  964. /*
  965.    called after relaxing, change the frags so they know how big they are
  966.  */
  967. void
  968. md_convert_frag (headers, fragP)
  969.      object_headers *headers;
  970.      fragS *fragP;
  971.  
  972. {
  973.   unsigned char *buffer = (unsigned char *) (fragP->fr_fix + fragP->fr_literal);
  974.   int donerelax = 0;
  975.   int targ_addr = ((fragP->fr_symbol ? S_GET_VALUE (fragP->fr_symbol) : 0) + fragP->fr_offset);
  976.   switch (fragP->fr_subtype)
  977.     {
  978.     case C (COND_JUMP, COND8):
  979.       {
  980.     /* Get the address of the end of the instruction */
  981.     int next_inst = fragP->fr_fix + fragP->fr_address + 2;
  982.  
  983.     int disp = targ_addr - next_inst - 2;
  984.     disp /= 2;
  985.     
  986.     md_number_to_chars (buffer + 1, disp & 0xff, 1);
  987.     fragP->fr_fix += 2;
  988.     fragP->fr_var = 0;
  989.       }
  990.       break;
  991.  
  992.     case C (UNCOND_JUMP, UNCOND12):
  993.       {
  994.     /* Get the address of the end of the instruction */
  995.     int next_inst = fragP->fr_fix + fragP->fr_address + 2;
  996.  
  997.     int t;
  998.     int disp = targ_addr - next_inst - 2;
  999.  
  1000.     disp /= 2;
  1001.     t = buffer[0] & 0xf0;
  1002.     md_number_to_chars (buffer, disp & 0xfff, 2);
  1003.     buffer[0] = (buffer[0] & 0xf) | t;
  1004.     fragP->fr_fix += 2;
  1005.     fragP->fr_var = 0;
  1006.       }
  1007.       break;
  1008.  
  1009.     case C (UNCOND_JUMP, UNCOND32):
  1010.     case C (UNCOND_JUMP, UNDEF_WORD_DISP):
  1011.       {
  1012.     /* A jump wont fit in 12 bits, make code which looks like
  1013.        bra foo
  1014.        mov.w @(0, PC), r14
  1015.        .long disp
  1016.        foo: bra @r14
  1017.      */
  1018.  
  1019.     int next_inst =
  1020.     fragP->fr_fix + fragP->fr_address + UNCOND32_LENGTH;
  1021.  
  1022.     int disp = targ_addr - next_inst;
  1023.     int t = buffer[0] & 0x10;
  1024.  
  1025.     disp /= 2;
  1026.  
  1027.     buffer[0] = 0xa0;    /* branch over move and disp */
  1028.     buffer[1] = 3;
  1029.     buffer[2] = 0xd0 | JREG;    /* Build mov insn */
  1030.     buffer[3] = 0x00;
  1031.  
  1032.     buffer[4] = 0;        /* space for 32 bit jump disp */
  1033.     buffer[5] = 0;
  1034.     buffer[6] = 0;
  1035.     buffer[7] = 0;
  1036.  
  1037.     buffer[10] = 0x40 | JREG;    /* Build jmp @JREG */
  1038.     buffer[11] = t ? 0xb : 0x2b;
  1039.  
  1040.     buffer[12] = 0x20;    /* build nop */
  1041.     buffer[13] = 0x0b;
  1042.  
  1043.     /* Make reloc for the long disp */
  1044.     fix_new (fragP,
  1045.          fragP->fr_fix + 4,
  1046.          4,
  1047.          fragP->fr_symbol,
  1048.          fragP->fr_offset,
  1049.          0,
  1050.          R_SH_IMM32);
  1051.     fragP->fr_fix += UNCOND32_LENGTH;
  1052.     fragP->fr_var = 0;
  1053.     donerelax = 1;
  1054.  
  1055.       }
  1056.       break;
  1057.  
  1058.     case C (COND_JUMP, COND12):
  1059.       {
  1060.     /* A bcond won't fit, so turn it into a b!cond; bra disp; nop */
  1061.     int next_inst =
  1062.     fragP->fr_fix + fragP->fr_address + 6;
  1063.  
  1064.     int disp = targ_addr - next_inst;
  1065.     disp /= 2;
  1066.     md_number_to_chars (buffer + 2, disp & 0xfff, 2);
  1067.     buffer[0] ^= 0x2;    /* Toggle T/F bit */
  1068.     buffer[1] = 1;        /* branch over jump and nop */
  1069.     buffer[2] = (buffer[2] & 0xf) | 0xa0;    /* Build jump insn */
  1070.     buffer[4] = 0x20;    /* Build nop */
  1071.     buffer[5] = 0x0b;
  1072.     fragP->fr_fix += 6;
  1073.     fragP->fr_var = 0;
  1074.     donerelax = 1;
  1075.       }
  1076.       break;
  1077.  
  1078.     case C (COND_JUMP, COND32):
  1079.     case C (COND_JUMP, UNDEF_WORD_DISP):
  1080.       {
  1081.     /* A bcond won't fit and it won't go into a 12 bit
  1082.        displacement either, the code sequence looks like:
  1083.        b!cond foop
  1084.        mov.w @(n, PC), r14
  1085.        jmp  @r14
  1086.        nop
  1087.        .long where
  1088.        foop:
  1089.      */
  1090.  
  1091.     int next_inst =
  1092.     fragP->fr_fix + fragP->fr_address + COND32_LENGTH;
  1093.  
  1094.     int disp = targ_addr - next_inst;
  1095.     disp /= 2;
  1096.  
  1097.     buffer[0] ^= 0x2;    /* Toggle T/F bit */
  1098. #define JREG 14
  1099.     buffer[1] = 5;        /* branch over mov, jump, nop and ptr */
  1100.     buffer[2] = 0xd0 | JREG;    /* Build mov insn */
  1101.     buffer[3] = 0x2;
  1102.     buffer[4] = 0x40 | JREG;    /* Build jmp @JREG */
  1103.     buffer[5] = 0x0b;
  1104.     buffer[6] = 0x20;    /* build nop */
  1105.     buffer[7] = 0x0b;
  1106.     buffer[8] = 0;        /* space for 32 bit jump disp */
  1107.     buffer[9] = 0;
  1108.     buffer[10] = 0;
  1109.     buffer[11] = 0;
  1110.     buffer[12] = 0;
  1111.     buffer[13] = 0;
  1112.     /* Make reloc for the long disp */
  1113.     fix_new (fragP,
  1114.          fragP->fr_fix + 8,
  1115.          4,
  1116.          fragP->fr_symbol,
  1117.          fragP->fr_offset,
  1118.          0,
  1119.          R_SH_IMM32);
  1120.     fragP->fr_fix += COND32_LENGTH;
  1121.     fragP->fr_var = 0;
  1122.     donerelax = 1;
  1123.       }
  1124.       break;
  1125.  
  1126.     default:
  1127.       abort ();
  1128.     }
  1129.  
  1130.   if (donerelax && !relax)
  1131.     {
  1132.       as_warn ("Offset doesn't fit at 0x%x, trying to get to %s+0x%x",
  1133.            fragP->fr_address,
  1134.            fragP->fr_symbol  ?    S_GET_NAME(fragP->fr_symbol): "",
  1135.            targ_addr);
  1136.     }
  1137.  
  1138. }
  1139.  
  1140. valueT
  1141. DEFUN (md_section_align, (seg, size),
  1142.        segT seg AND
  1143.        valueT size)
  1144. {
  1145.   return ((size + (1 << section_alignment[(int) seg]) - 1)
  1146.       & (-1 << section_alignment[(int) seg]));
  1147.  
  1148. }
  1149.  
  1150. void
  1151. md_apply_fix (fixP, val)
  1152.      fixS *fixP;
  1153.      long val;
  1154. {
  1155.   char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
  1156.   int addr = fixP->fx_frag->fr_address + fixP->fx_where;
  1157.  
  1158.   if (fixP->fx_r_type == 0)
  1159.     {
  1160.       if (fixP->fx_size == 2)
  1161.     fixP->fx_r_type = R_SH_IMM16;
  1162.       else
  1163.     fixP->fx_r_type = R_SH_IMM32;
  1164.     }
  1165.  
  1166.   switch (fixP->fx_r_type)
  1167.     {
  1168.  
  1169.     case R_SH_IMM4:
  1170.       *buf = (*buf & 0xf0) | (val & 0xf);
  1171.       break;
  1172.  
  1173.     case R_SH_IMM4BY2:
  1174.       *buf = (*buf & 0xf0) | ((val >> 1) & 0xf);
  1175.       break;
  1176.  
  1177.     case R_SH_IMM4BY4:
  1178.       *buf = (*buf & 0xf0) | ((val >> 2) & 0xf);
  1179.       break;
  1180.  
  1181.     case R_SH_IMM8BY2:
  1182.       *buf = val >> 1;
  1183.       break;
  1184.  
  1185.     case R_SH_IMM8BY4:
  1186.       *buf = val >> 2;
  1187.       break;
  1188.  
  1189.     case R_SH_IMM8:
  1190.       *buf++ = val;
  1191.       break;
  1192.  
  1193.     case R_SH_PCRELIMM8BY4:
  1194.       addr &= ~1;
  1195. #if 0
  1196.       if (val & 0x3)
  1197.     as_warn ("non aligned displacement at %x\n", addr);
  1198. #endif
  1199.       /*      val -= (addr + 4); */
  1200.       val += 3;
  1201.       val /= 4;
  1202.       if (val & ~0xff)
  1203.     as_warn ("pcrel too far at %x\n", addr);
  1204.  
  1205.       *buf = val;
  1206.       break;
  1207.  
  1208.     case R_SH_PCRELIMM8BY2:
  1209.       addr &= ~1;
  1210.       if (val & 0x1)
  1211.     as_bad ("odd displacement at %x\n", addr);
  1212.       /*      val -= (addr + 4); */
  1213.       val++;
  1214.       val /= 2;
  1215.       if (val & ~0xff)
  1216.     as_warn ("pcrel too far at %x\n", addr);
  1217.       *buf = val;
  1218.       break;
  1219.  
  1220.     case R_SH_IMM32:
  1221.       *buf++ = val >> 24;
  1222.       *buf++ = val >> 16;
  1223.       *buf++ = val >> 8;
  1224.       *buf++ = val >> 0;
  1225.       break;
  1226.  
  1227.     case R_SH_IMM16:
  1228.       *buf++ = val >> 8;
  1229.       *buf++ = val >> 0;
  1230.       break;
  1231.  
  1232.     default:
  1233.       abort ();
  1234.     }
  1235. }
  1236.  
  1237. void
  1238. DEFUN (md_operand, (expressionP), expressionS * expressionP)
  1239. {
  1240. }
  1241.  
  1242. int md_long_jump_size;
  1243.  
  1244. /*
  1245.    called just before address relaxation, return the length
  1246.    by which a fragment must grow to reach it's destination
  1247.  */
  1248. int
  1249. md_estimate_size_before_relax (fragP, segment_type)
  1250.      register fragS *fragP;
  1251.      register segT segment_type;
  1252. {
  1253.   switch (fragP->fr_subtype)
  1254.     {
  1255.     case C (UNCOND_JUMP, UNDEF_DISP):
  1256.       /* used to be a branch to somewhere which was unknown */
  1257.       if (!fragP->fr_symbol)
  1258.     {
  1259.       fragP->fr_subtype = C (UNCOND_JUMP, UNCOND12);
  1260.       fragP->fr_var = md_relax_table[C (UNCOND_JUMP, UNCOND12)].rlx_length;
  1261.     }
  1262.       else if (S_GET_SEGMENT (fragP->fr_symbol) == segment_type)
  1263.     {
  1264.       fragP->fr_subtype = C (UNCOND_JUMP, UNCOND12);
  1265.       fragP->fr_var = md_relax_table[C (UNCOND_JUMP, UNCOND12)].rlx_length;
  1266.     }
  1267.       else
  1268.     {
  1269.       fragP->fr_subtype = C (UNCOND_JUMP, UNDEF_WORD_DISP);
  1270.       fragP->fr_var = md_relax_table[C (UNCOND_JUMP, UNCOND32)].rlx_length;
  1271.       return md_relax_table[C (UNCOND_JUMP, UNCOND32)].rlx_length;
  1272.     }
  1273.       break;
  1274.  
  1275.     default:
  1276.       abort ();
  1277.     case C (COND_JUMP, UNDEF_DISP):
  1278.       /* used to be a branch to somewhere which was unknown */
  1279.       if (fragP->fr_symbol
  1280.       && S_GET_SEGMENT (fragP->fr_symbol) == segment_type)
  1281.     {
  1282.       /* Got a symbol and it's defined in this segment, become byte
  1283.          sized - maybe it will fix up */
  1284.       fragP->fr_subtype = C (COND_JUMP, COND8);
  1285.       fragP->fr_var = md_relax_table[C (COND_JUMP, COND8)].rlx_length;
  1286.     }
  1287.       else if (fragP->fr_symbol)
  1288.     {
  1289.       /* Its got a segment, but its not ours, so it will always be long */
  1290.       fragP->fr_subtype = C (COND_JUMP, UNDEF_WORD_DISP);
  1291.       fragP->fr_var = md_relax_table[C (COND_JUMP, COND32)].rlx_length;
  1292.       return md_relax_table[C (COND_JUMP, COND32)].rlx_length;
  1293.     }
  1294.       else
  1295.     {
  1296.       /* We know the abs value */
  1297.       fragP->fr_subtype = C (COND_JUMP, COND8);
  1298.       fragP->fr_var = md_relax_table[C (COND_JUMP, COND8)].rlx_length;
  1299.     }
  1300.  
  1301.       break;
  1302.     }
  1303.   return fragP->fr_var;
  1304. }
  1305.  
  1306. /* Put number into target byte order */
  1307.  
  1308. void
  1309. md_number_to_chars (ptr, use, nbytes)
  1310.      char *ptr;
  1311.      valueT use;
  1312.      int nbytes;
  1313. {
  1314.   number_to_chars_bigendian (ptr, use, nbytes);
  1315. }
  1316.  
  1317. long
  1318. md_pcrel_from (fixP)
  1319.      fixS *fixP;
  1320. {
  1321.   int gap = fixP->fx_size + fixP->fx_where +  fixP->fx_frag->fr_address - 1 ;
  1322.   return gap;
  1323. }
  1324.  
  1325. short
  1326. tc_coff_fix2rtype (fix_ptr)
  1327.      fixS *fix_ptr;
  1328. {
  1329.   if (fix_ptr->fx_r_type == RELOC_32)
  1330.     {
  1331.       /* cons likes to create reloc32's whatever the size of the reloc..
  1332.        */
  1333.       switch (fix_ptr->fx_size)
  1334.     {
  1335.     case 2:
  1336.       return R_SH_IMM16;
  1337.       break;
  1338.     case 1:
  1339.       return R_SH_IMM8;
  1340.       break;
  1341.     default:
  1342.       abort ();
  1343.     }
  1344.     }
  1345.   return R_SH_IMM32;
  1346. }
  1347.  
  1348. int
  1349. tc_coff_sizemachdep (frag)
  1350.      fragS *frag;
  1351. {
  1352.   return md_relax_table[frag->fr_subtype].rlx_length;
  1353. }
  1354.